// 支付工具类
import { createOrder, payOrder, getFeeList } from './api.js'

/**
 * 支付工具类
 */
class PaymentUtil {
    /**
     * 获取费用列表
     * @returns {Promise} 费用列表
     */
    static async getFeeList() {
        try {
            const result = await getFeeList()
            return result
        } catch (error) {
            console.error('获取费用列表失败:', error)
            throw error
        }
    }

    /**
     * 生成订单号
     * @returns {string} 订单号
     */
    static generateOrderNo() {
        const timestamp = Date.now()
        const random = Math.floor(Math.random() * 1000)
        return `ORDER${timestamp}${random}`
    }

    /**
     * 创建订单
     * @param {Object} orderData 订单数据，只需要包含feeId
     * @returns {Promise} 创建订单结果
     */
    static async createOrder(orderData) {
        try {
            const result = await createOrder(orderData)
            return result
        } catch (error) {
            console.error('创建订单失败:', error)
            throw error
        }
    }

    /**
     * 调用支付接口
     * @param {Object} payData 支付数据，只需要包含orderId
     * @returns {Promise} 支付结果
     */
    static async callPay(payData) {
        try {
            const result = await payOrder(payData)
            return result
        } catch (error) {
            console.error('调用支付接口失败:', error)
            throw error
        }
    }

    /**
     * 调用微信支付
     * @param {Object} payData 支付数据
     * @returns {Promise} 支付结果
     */
    static callWechatPay(payData) {
        return new Promise((resolve, reject) => {
            uni.requestPayment({
                provider: 'wxpay',
                timeStamp: payData.timeStamp,
                nonceStr: payData.nonceStr,
                package: payData.packageVal,
                signType: payData.signType,
                paySign: payData.paySign,
                success: (res) => {
                    console.log('微信支付成功:', res)
                    resolve(res)
                },
                fail: (err) => {
                    console.error('微信支付失败:', err)
                    reject(err)
                }
            })
        })
    }

    /**
     * 完整的支付流程
     * @param {string} feeId 费用ID
     * @param {number} amount 支付金额（元）
     * @param {string} userId 用户ID
     * @param {string} orderType 订单类型
     * @returns {Promise} 支付结果
     */
    static async processPayment(feeId, amount, userId, orderType = 'membership') {
        try {
            // 1. 创建订单（后端会根据feeId自动获取费用信息）
            uni.showLoading({ title: '创建订单中...' })
            const orderData = {
                feeId: feeId // 费用ID
            }
            
            const orderResult = await this.createOrder(orderData)
            
            if (!orderResult.code == 0) {
                throw new Error(orderResult.message || '创建订单失败')
            }
            
            const orderId = orderResult.data?.orderId || orderResult.data?.id
            
            // 2. 如果是青少年免费缴费（feeId为-1），直接返回成功，不调用支付接口
            if (feeId === -1 || feeId === '-1') {
                uni.hideLoading()
                return {
                    success: true,
                    orderId: orderId,
                    amount: amount,
                    isTeenager: true
                }
            }
            
            // 3. 正常缴费流程：调用支付接口
            uni.showLoading({ title: '获取支付信息...' })
            const payData = {
                orderId: orderId
            }
            
            const payResult = await this.callPay(payData)
            
            if (!payResult.code == 0) {
                throw new Error(payResult.message || '获取支付信息失败')
            }
            
            // 4. 调用微信支付（使用返回的支付参数：timeStamp、nonceStr、package、signType、paySign）
            uni.hideLoading()
            uni.showLoading({ title: '调起支付...' })
            
            await this.callWechatPay(payResult.data)
            
            // 5. 支付成功
            uni.hideLoading()
            return {
                success: true,
                orderId: orderId,
                amount: amount
            }
            
        } catch (error) {
            uni.hideLoading()
            throw error
        }
    }

    /**
     * 处理支付错误
     * @param {Error} error 错误对象
     * @returns {string} 错误信息
     */
    static handlePaymentError(error) {
        let errorMessage = '支付失败，请重试'
        
        if (error.errMsg) {
            if (error.errMsg.includes('cancel')) {
                errorMessage = '支付已取消'
            } else if (error.errMsg.includes('fail')) {
                errorMessage = '支付失败，请重试'
            }
        } else if (error.message) {
            errorMessage = error.message
        }
        
        return errorMessage
    }

    /**
     * 格式化金额显示
     * @param {number} amount 金额
     * @returns {string} 格式化后的金额
     */
    static formatAmount(amount) {
        return amount.toFixed(2)
    }

    /**
     * 验证支付金额
     * @param {number} amount 金额
     * @returns {boolean} 是否有效
     */
    static validateAmount(amount) {
        return amount >= 0 && amount <= 10000 // 允许0元（青少年免费），最大10000元
    }
}

export default PaymentUtil 